package marketplace.ejb.controller;

import java.util.ArrayList;
import java.util.List;

import javax.ejb.EJB;
import javax.ejb.Stateless;

import marketplace.ejb.interfaces.IContenidoDigitalEJB;
import marketplace.jpa.datas.DataCategoria;
import marketplace.jpa.datas.DataContenidoDigital;
import marketplace.jpa.datas.DataSubcategoria;
import marketplace.jpa.datas.DataVenta;
import marketplace.jpa.datas.DataVersion;
import marketplace.jpa.interfaces.IContenidoDigitalDAO;
import marketplace.jpa.interfaces.IUsuarioDAO;
import marketplace.jpa.interfaces.IVentaDAO;

@Stateless
public class CTRLContenidoDigitalEJB implements IContenidoDigitalEJB{
	
	@EJB
	IContenidoDigitalDAO dao;
	@EJB
	IUsuarioDAO daoProveedor;
	@EJB
	IVentaDAO daoVenta;	
	
	@Override
	public boolean existeContenidoDigital(int id) throws Exception {
		return dao.existeContenidoDigital(id);
	}
	
	@Override
	public boolean existeContenidoDigital(String nombre) throws Exception {
		return dao.existeContenidoDigital(nombre);
	}	

	@Override
	public int guardarContenidoDigital(String nombre, String descripcion, String videos, String subcategoria, String propietario) throws Exception {
		return dao.guardarContenidoDigital(nombre, descripcion, videos, subcategoria, propietario);
	}

	@Override
	public void modificarContenidoDigital(DataContenidoDigital cd) throws Exception {
		dao.modificarContenidoDigital(cd);
	}

	@Override
	public void eliminarContenidoDigital(int id) throws Exception {
		dao.eliminarVersionesContenidoDigital(id);
		dao.eliminarContenidoDigital(id);
	}

	@Override
	public List<DataContenidoDigital> getContenidoDigitales() throws Exception {
		return dao.getContenidoDigitales();
	}
	
	@Override
	public List<DataContenidoDigital> getContenidoDigitalesProveedor(String mail) throws Exception{
		return dao.getContenidoDigitalesProveedor(mail);
	}

	@Override
	public List<DataContenidoDigital> getContenidoDigitalesSubcategorias(String subcategoria) throws Exception{
		ArrayList<DataContenidoDigital> devolver = new ArrayList<DataContenidoDigital>();
		for (DataContenidoDigital dataContenidoDigital : getContenidosDigitalesConVersionesAutorizadas()) {
			if (dataContenidoDigital.getSubcategoria().getNombre().equals(subcategoria)){
					devolver.add(dataContenidoDigital);
			}
		}
		return devolver;
	}
	
	@Override
	public DataContenidoDigital obtenerContenidoDigital(int id) throws Exception {
		return dao.obtenerContenidoDigital(id);
	}

	
	//// CATEGORIA /////////////////////////////////////////////////////////////////	
	
	@Override
	public boolean existeCategoria(String nombre) throws Exception {
		return dao.existeCategoria(nombre);
	}

	@Override
	public boolean guardarCategoria(String nombre, String descripcion) throws Exception {
		DataCategoria da = new DataCategoria(nombre, descripcion);
		return dao.guardarCategoria(da);
	}

	@Override
	public void modificarCategoria(DataCategoria da) throws Exception {
		dao.modificarCategoria(da);		
	}

	@Override
	public void eliminarCategoria(String nombre) throws Exception {
		dao.eliminarSubcategoriasCategoria(nombre);
		dao.eliminarCategoria(nombre);
	}

	@Override
	public List<DataCategoria> getCategorias() throws Exception {
		return dao.getCategorias();
	}

	@Override
	public List<String> getNombresCategorias() throws Exception {
		ArrayList<String> devolver = new ArrayList<String>();
		for (DataCategoria dc : dao.getCategorias()) {
			devolver.add(dc.getNombre());
		}
		return devolver;
	}	
	
	@Override
	public DataCategoria obtenerCategoria(String c) throws Exception {
		return dao.obtenerCategoria(c);
	}
	
	
	////SUBCATEGORIA /////////////////////////////////////////////////////////////////	

	@Override
	public boolean existeSubCategoria(String scnombre, String categoria) throws Exception {
		return dao.existeSubCategoria(scnombre, categoria);
	}

	@Override
	public boolean guardarSubCategoria(String scnombre, String scdescripcion, String categoria) throws Exception {
		DataCategoria dc = dao.obtenerCategoria(categoria);
		DataSubcategoria dsc =  new DataSubcategoria(scnombre, scdescripcion, dc);
		return dao.guardarSubCategoria(dsc);
	}

	@Override
	public void modificarSubCategoria(DataSubcategoria dsc) throws Exception {
		DataCategoria dc = dao.obtenerCategoria(dsc.getCategoria().getNombre());
		DataSubcategoria dscNew = new DataSubcategoria(dsc.getNombre(), dsc.getDescripcion(), dc);		
		dao.modificarSubCategoria(dscNew);
	}

	@Override
	public void eliminarSubCategoria(String sc) throws Exception {
		dao.eliminarSubCategoria(sc);
	}
	
	@Override
	public List<DataSubcategoria> getSubCategorias() throws Exception {
		return dao.getSubCategorias();
	}
	
	@Override
	public List<DataSubcategoria> getSubCategoriasPorCategoria(String categoria) throws Exception {
		return dao.getSubCategoriasPorCategoria(categoria);
	}
		
	@Override
	public List<String> getNombresSubCategoriasPorCategoria(String categoria) throws Exception {		
		ArrayList<String> devolver = new ArrayList<String>();
		for (DataSubcategoria dc : dao.getSubCategoriasPorCategoria(categoria)) {
			devolver.add(dc.getNombre());
		}
		return devolver;		
	}
	
	@Override
	public DataSubcategoria obtenerSubCategoria(String scnombre) throws Exception {
		return dao.obtenerSubCategoria(scnombre);
	}
	
	@Override
	public List<DataCategoria> getCategoriasConSubcategorias(){
		List<DataCategoria> devdc = new ArrayList<DataCategoria>();
		try {
			List<DataSubcategoria> dsc = dao.getSubCategorias();
			List<DataCategoria> dc = dao.getCategorias();
			for (DataCategoria dC : dc) {
				for (DataSubcategoria dS : dsc) {
					if (dS.getCategoria().equals(dC)){
						if (!devdc.contains(dC))
							devdc.add(dC);
					}
				}
			}			
		} catch (Exception e) {
			System.out.println("ERROR CTRLContenidoDigital: getCategoriasConSubcategrias: " + e.getMessage());
		}		
		return devdc;
	}

	

	
	//// VERSION ///////////////////////////////////////////////////////////////////////
	
		
	@Override
	public boolean existeVersion(int id) throws Exception {
		return dao.existeVersion(id);
	}

	@Override
	public boolean existeVersionNumero(int idContenido, int numero) throws Exception {
		return dao.existeVersionNumero(idContenido, numero);
	}

	@Override
	public int guardarVersion(int numero, String nombre, Double precio, String estado, String archivo, Double tamanio, int idContenido) {
		return dao.guardarVersion(numero, nombre, precio, estado, archivo, tamanio, idContenido);
	}

	@Override
	public void modificarVersion(DataVersion Ver) throws Exception {
		dao.modificarVersion(Ver);
	}

	@Override
	public void eliminarVersion(int id) throws Exception {
		dao.eliminarVersion(id);
	}

	@Override
	public List<DataVersion> getVersiones() throws Exception {
		return dao.getVersiones();
	}

	@Override
	public List<DataVersion> getVersiones(int idContenido) throws Exception {
		return dao.getVersiones();
	}

	@Override
	public List<DataVersion> getVersionesProveedor(String mailProveedor) throws Exception {
		ArrayList<DataVersion> lstVersiones = (ArrayList<DataVersion>) getVersiones();
		ArrayList<DataVersion> devolver = new ArrayList<DataVersion>();		
		for (DataVersion dataVersion : lstVersiones) {
			if(dataVersion.getContDig().getProveedor().getMail().equals(mailProveedor)){
				devolver.add(dataVersion);				
			}
		}
		return devolver;
	}
	
	@Override
	public DataVersion obtenerVersion(int id) throws Exception {
		return dao.obtenerVersion(id);
	}

	@Override
	public ArrayList<DataVersion> getVersionesPendientes() throws Exception {
		ArrayList<DataVersion> lstVersiones = (ArrayList<DataVersion>) getVersiones();
		ArrayList<DataVersion> devolver = new ArrayList<DataVersion>();		
		for (DataVersion dataVersion : lstVersiones) {
			if(dataVersion.getEstadoAprobacion().equals("PENDIENTE")){
				devolver.add(dataVersion);
			}
		}
		return devolver;
	}

	@Override
	public List<DataContenidoDigital> getContenidosDigitalesConVersionesAutorizadas() throws Exception {
		ArrayList<DataContenidoDigital> lstVersiones = (ArrayList<DataContenidoDigital>) dao.getContenidosConVersionesAprobadas();
		ArrayList<DataContenidoDigital> devolver = new ArrayList<DataContenidoDigital>();		
		for (DataContenidoDigital dataContenidoDigital : lstVersiones) {
			if(!existeContenidoDigitalLista(dataContenidoDigital, devolver))
				devolver.add(dataContenidoDigital);
		}
		return devolver;
	}

	
	private boolean existeContenidoDigitalLista(DataContenidoDigital dcd, ArrayList<DataContenidoDigital> lista){
		boolean devolver = false;
		int i = 0;
		while ((i < lista.size()) && (devolver==false)) {
			if (lista!=null){
				if (lista.get(i).getIdContenido() == dcd.getIdContenido()) devolver = true;
				i++;
			}
		}
		return devolver;		
	}
	
	@Override
	public int getCantidadDescargasContenidoDigital(int idContenido) throws Exception{
		return dao.getCantidadDescargasContenidoDigital(idContenido);
	}	
	
	
	/*@Override*/
	public ArrayList<DataVersion> obtenerVersionesVendidasNoGratis() throws Exception{
		
		ArrayList<DataVersion> version = new ArrayList<DataVersion>();
		
		ArrayList<Integer> idVersiones = new ArrayList<Integer>();
		ArrayList<DataVenta> ventas = daoVenta.obtenerVentas();
		
		for (DataVenta dataVenta : ventas) {
			if (dataVenta.getMonto() != 0.0){
				if (!idVersiones.contains(dataVenta.getIdVenta())){
						idVersiones.add(dataVenta.getIdVenta());
						version.add(obtenerVersion(dataVenta.getIdVenta()));
				}
			}
		}		
		return version;
	}
	
	@Override
	public DataVersion obtenerDataUltimaVersionAutorizada(int idContenido) throws Exception{		
		return dao.obtenerDataUltimaVersionAutorizada(idContenido);
	}

	@Override
	public void guardarRegistroDeAutorizacion(String administrador, int idVersion, String observacion) throws Exception {
		dao.guardarRegistroDeAutorizacion(administrador, idVersion, observacion);		
	}
	
	@Override
	public List<DataContenidoDigital> getContenidoDigitalesBusqueda(String valor) {		
		return dao.obtenerBusqueda(valor);
	}

	@Override
	public boolean existeSubCategoriaNombre(String nombre) {
		return dao.existeSubCategoriaNombre(nombre);
	}

}

